package com.yfbao.horizon.schedule.tk.conf;

import com.yfbao.horizon.schedule.tk.common.FstSerializer;
import lombok.extern.slf4j.Slf4j;
import org.nustaq.serialization.FSTConfiguration;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.RedisSerializer;


/**
 * @program: RedisBoot
 * @description: redis配置类
 * @create: 2023-06-28 15:29
 **/
@Slf4j
@Configuration
@EnableCaching //开启注解
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * retemplate相关配置
     */
//    @Bean
//    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
//
//        RedisTemplate<String, Object> template = new RedisTemplate<>();
//        // 配置连接工厂
//        template.setConnectionFactory(factory);
//
//        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
//        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
//
//        ObjectMapper om = new ObjectMapper();
//        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
//        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
//        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
//        jacksonSeial.setObjectMapper(om);
//
//        // 值采用json序列化
//        template.setValueSerializer(jacksonSeial);
//        //使用StringRedisSerializer来序列化和反序列化redis的key值
//        template.setKeySerializer(new StringRedisSerializer());
//
//        // 设置hash key 和value序列化模式
//        template.setHashKeySerializer(new StringRedisSerializer());
//        template.setHashValueSerializer(jacksonSeial);
//        template.afterPropertiesSet();
//        return template;
//    }




    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        RedisTemplate<Object, Object> template = new CtpRedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        FSTConfiguration fstConfiguration = FSTConfiguration.createDefaultConfiguration();
        RedisSerializer<Object> fstSerializer = new FstSerializer(fstConfiguration);

        template.setDefaultSerializer(fstSerializer);
        template.setKeySerializer(fstSerializer);
        template.setValueSerializer(fstSerializer);
        template.setHashKeySerializer(fstSerializer);
        template.setHashValueSerializer(fstSerializer);

        return template;
    }


//    @Bean
//    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//        RedisTemplate<Object, Object> template = new RedisTemplate<>();
//        template.setConnectionFactory(redisConnectionFactory);
//
//        DefaultKeySerializer defaultKeySerializer = new DefaultKeySerializer();
//        JacksonRedisSerializer jacksonRedisSerializer = new JacksonRedisSerializer();
//
//        template.setConnectionFactory(redisConnectionFactory);
//        template.setKeySerializer(defaultKeySerializer);
//        template.setHashKeySerializer(defaultKeySerializer);
//
//        template.setDefaultSerializer(jacksonRedisSerializer);
//
//
//        return template;
//    }

//    /**
//     * 对hash类型的数据操作
//     */
//    @Bean
//    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
//        return redisTemplate.opsForHash();
//    }
//
//    /**
//     * 对redis字符串类型数据操作
//     */
//    @Bean
//    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
//        return redisTemplate.opsForValue();
//    }
//
//    /**
//     * 对链表类型的数据操作
//     */
//    @Bean
//    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
//        return redisTemplate.opsForList();
//    }
//
//    /**
//     * 对无序集合类型的数据操作
//     */
//    @Bean
//    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
//        return redisTemplate.opsForSet();
//    }
//
//    /**
//     * 对有序集合类型的数据操作
//     */
//    @Bean
//    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
//        return redisTemplate.opsForZSet();
//    }


//    @Bean
//    @ConditionalOnProperty(name = "spring.redis.client-type", havingValue = "jedis")
//    public JedisPoolConfig jedisPoolConfig() {
//        String minIdle = System.getProperty("spring.redis.jedis.pool.minIdle", "10");
//        String maxIdle = System.getProperty("spring.redis.jedis.pool.maxIdle","100");
//        String maxActive = System.getProperty("spring.redis.jedis.pool.maxActive","50");
//        String maxWait = System.getProperty("spring.redis.jedis.pool.maxWait","500");
//        JedisPoolConfig poolConfig = new JedisPoolConfig();
//        poolConfig.setMaxTotal(Integer.valueOf(maxIdle));  // 最大连接数
//        poolConfig.setMaxIdle(Integer.valueOf(maxActive));    // 最大空闲连接数
//        poolConfig.setMinIdle(Integer.valueOf(minIdle));    // 最小空闲连接数
//        poolConfig.setMaxWaitMillis(Integer.valueOf(maxWait));  // 最大等待时间
//        return poolConfig;
//    }
//    @Bean
//    @ConditionalOnProperty(name = "spring.redis.client-type", havingValue = "jedis")
//    public JedisPool jedisPool(JedisPoolConfig poolConfig) {
//        return new JedisPool(poolConfig, "localhost", 6379, 2000);  // 主机、端口、超时设置
//    }

//    @Bean
//    public JedisSentinelPool jedisSentinelPool(JedisPoolConfig poolConfig) {
//        Set<String> sentinels = new HashSet<>();
//        sentinels.add("127.0.0.1:26379");  // 哨兵的地址
//        sentinels.add("127.0.0.2:26379");
//        String masterName = "mymaster";  // 哨兵监控的主节点名称
//
//        return new JedisSentinelPool(masterName, sentinels, poolConfig);
//    }
//
//    @Bean
//    public JedisCluster jedisCluster(JedisPoolConfig poolConfig) {
//        Set<HostAndPort> clusterNodes = new HashSet<>();
//        clusterNodes.add(new HostAndPort("127.0.0.1", 7000));
//        clusterNodes.add(new HostAndPort("127.0.0.2", 7001));
//        clusterNodes.add(new HostAndPort("127.0.0.3", 7002));
//
//        return new JedisCluster(clusterNodes, 2000, 2000, 5, poolConfig);  // 节点信息、超时时间、最大重试次数等
//    }

//    @Bean
//    @ConditionalOnProperty(name = "spring.redis.client-type", havingValue = "jedis")
//    public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig poolConfig) {
//        JedisConnectionFactory factory = new JedisConnectionFactory(poolConfig);
//        factory.setHostName("localhost");
//        factory.setPort(6379);
//        factory.setUsePool(true);
//        return factory;
//    }

//    @Bean
//    @ConditionalOnProperty(name = "spring.redis.client-type", havingValue = "jedis")
//    public JedisPool jedisPool(JedisConnectionFactory jedisConnectionFactory) {
//        try {
//            Field jedisPoolField  = JedisConnectionFactory.class.getDeclaredField("pool");
//            jedisPoolField.setAccessible(true);
//            JedisPool jedisPool =   (JedisPool) jedisPoolField.get(jedisConnectionFactory);
//            return jedisPool;
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        } catch (NoSuchFieldException e) {
//            e.printStackTrace();
//        }
//        log.warn("register jedisPool error");
//        return null;
//    }




}
